package org.example.demo1.util;

import io.fabric8.kubernetes.client.Config;
import io.fabric8.kubernetes.client.DefaultKubernetesClient;
import io.fabric8.kubernetes.client.KubernetesClient;
import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

@Slf4j
public class KubernetesClientUtil {

    private static final String KUBECONFIG_PATH = "D:\\whu-ops\\src\\main\\resources\\templates\\config";
    private static final int CONNECTION_TIMEOUT_SECONDS = 10;
    private static final int REQUEST_TIMEOUT_SECONDS = 15;

    // [NEW] 使用ThreadLocal来为每个线程（即每次AI请求）缓存一个客户端实例
    private static final ThreadLocal<KubernetesClient> clientCache = new ThreadLocal<>();

    /**
     * [MODIFIED] 获取一个KubernetesClient实例。
     * 如果当前线程已存在缓存实例，则直接返回；否则创建一个新的并缓存。
     *
     * @return 当前线程共享的KubernetesClient实例
     * @throws IOException 如果kubeconfig文件读取失败
     */
    public static KubernetesClient getClient() throws IOException {
        if (clientCache.get() == null) {
            log.info("当前线程无可用客户端，正在创建新的KubernetesClient实例...");
            KubernetesClient newClient = new DefaultKubernetesClient(createOptimizedConfig());
            clientCache.set(newClient);
        }
        return clientCache.get();
    }

    /**
     * [MODIFIED] 测试连接，并在成功时缓存客户端实例。
     *
     * @return 如果连接成功返回true，否则返回false
     */
    public static boolean testConnection() {
        try {
            // 首先检查缓存，如果已有，说明已连接
            if (clientCache.get() != null) {
                log.info("Kubernetes客户端已缓存，跳过重复连接测试。");
                return true;
            }

            // 如果没有缓存，则创建新客户端进行测试
            KubernetesClient client = getClient(); // 这会创建并缓存客户端
            client.getKubernetesVersion(); // 实际的测试动作
            log.info("Kubernetes 集群连接测试成功，并已缓存客户端实例。");
            return true;
        } catch (Exception e) {
            log.error("Kubernetes 集群连接测试失败: {}", e.getMessage());
            // 清理掉可能创建失败的客户端
            closeAndRemoveClient();
            return false;
        }
    }

    /**
     * [NEW] 关闭并从当前线程的缓存中移除客户端。
     * 这个方法应该在每次AI请求处理完成后被调用，以防资源泄露。
     */
    public static void closeAndRemoveClient() {
        KubernetesClient client = clientCache.get();
        if (client != null) {
            try {
                client.close();
                log.info("当前线程的KubernetesClient实例已成功关闭。");
            } catch (Exception e) {
                log.error("关闭KubernetesClient时出错: {}", e.getMessage(), e);
            } finally {
                clientCache.remove(); // 确保从ThreadLocal中移除
            }
        }
    }

    /**
     * 创建一个优化后的 Config 对象，用于 Kubernetes Client。
     * (此方法保持不变)
     * @return 优化后的 Config 对象
     * @throws IOException 如果 kubeconfig 文件读取失败
     */
    private static Config createOptimizedConfig() throws IOException {
        File kubeconfigFile = new File(KUBECONFIG_PATH);
        if (!kubeconfigFile.exists()) {
            throw new IOException("Kubeconfig file not found at: " + KUBECONFIG_PATH);
        }

        String kubeconfigContent = Files.readString(kubeconfigFile.toPath());
        Config config = Config.fromKubeconfig(kubeconfigContent);

        config.setConnectionTimeout(CONNECTION_TIMEOUT_SECONDS * 1000);
        config.setRequestTimeout(REQUEST_TIMEOUT_SECONDS * 1000);
        config.setRequestRetryBackoffLimit(2);
        config.setRequestRetryBackoffInterval(1000);

        return config;
    }
}
